package de.hatraco.funderberg.blackjack.controller;

import de.hatraco.funderberg.blackjack.data.GraphicsBlackJack;
import de.hatraco.funderberg.blackjack.model.*;
import de.hatraco.funderberg.blackjack.utils.TimerActionListener;
import de.hatraco.funderberg.blackjack.views.*;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Collections;
import javax.swing.Timer;

public class Main_Controller {
	
	//Singleton Pattern: Stellt sicher, dass nur eine Instanz von Main_Controller existiert
	private static Main_Controller instance = new Main_Controller();
	
	public static Main_Controller getInstance() {
		if (instance == null) {
			instance = new Main_Controller();
		}	
		return instance;
	}
	
	private Ctrl_MainView ctrl_mainview;
	private Ctrl_Dialogs ctrl_dialogs;
	
	private Deck deck;
	private Game game;
	private Player player;
	private MainView mainview;
	private StartDialog startdialog;
	private NamesDialog namesdialog;
	private StartstackDialog startstackdialog;
	private BetDialog betdialog;
	private RulesDialog rulesdialog;
	private InfoDialog infodialog;
	private ResultsDialog resultsdialog;
	private OutofstackDialog outofstackdialog;
	private ResolutionDialog resolutiondialog;
	private GraphicsBlackJack img;
	
	private int counter_dealcards;
	private int counter_doubledown;
	private int ace_corrector;
		
	private Timer timer_dealcards;
	private Timer timer_dealersmove;
	private Timer timer_doubledown;

	public Main_Controller() {
		
		//Instanziert Models, Views, Controller und Timer und aktiviert die Listener für alle Buttons
		this.ctrl_mainview = Ctrl_MainView.getInstance();
		this.ctrl_dialogs = Ctrl_Dialogs.getInstance();
		this.deck = Deck.getInstance();
		this.game = Game.getInstance();
		this.mainview = MainView.getInstanceWindow();
		this.startdialog = StartDialog.getInstance();
		this.namesdialog = NamesDialog.getInstance();
		this.startstackdialog = StartstackDialog.getInstance();
		this.betdialog = BetDialog.getInstance();
		this.rulesdialog = RulesDialog.getInstance();
		this.infodialog = InfoDialog.getInstance();
		this.resultsdialog = ResultsDialog.getInstance();
		this.outofstackdialog = OutofstackDialog.getInstance();
		this.resolutiondialog = ResolutionDialog.getInstance();
		this.img = GraphicsBlackJack.getInstance();
		
		this.timer_dealcards = new Timer(500, new TimerActionListener());
		this.timer_dealersmove = new Timer(500, new TimerActionListener());
		this.timer_doubledown = new Timer(500, new TimerActionListener());
		
		this.addListener();
	}
	
	//Öffnet das Fenster zur Auswahl der Auflösung
	public void showResDialog() {
		ctrl_dialogs.showDialog(resolutiondialog);
	}
	
	//Zeigt die mainview an und öffnet den startdialog
	public void showView() {
		mainview.setLocations();
		mainview.setVisible(true);
		ctrl_mainview.theClock();
		ctrl_dialogs.startGame();
	}
	
	//Fügt Spieler hinzu
	public void addPlayers(int quant) {
		for (int i = 0; i < quant; i++) {
			player = new Player();
			game.getPlayers().add(player);
		}
	}
	
	//TODO wird das benutzt?
	//Entfernt Spieler
	public void removePlayer(int player) {
		game.getPlayers().remove(player);
	}
	
	//Setzt den Stack eines Player und ruft die Methode auf, die den Stack in der View setzt
	public void setStack(int player, int stack) {
		game.getPlayers().get(player).setStack(stack);
		ctrl_mainview.setStack(player);
	}
	
	//Setzt das Ergebnis eines Spielers
	public void setResult() {
		//Prüft, ob eine Splithand gespielt wird
		if (game.getPlayers().get(game.getPl_on()).isSplitActive() == true) {
			int v = game.getPlayers().get(game.getPl_on()).getSplithand().getValue();
			//Hat der Spieler BlackJack? -> Result = 99
			if (v == 21 && game.getPlayers().get(game.getPl_on()).getSplithand().getCards().size() == 2) {
				game.getPlayers().get(game.getPl_on()).getSplithand().setResult(99);
			//Kein Blackjack? -> Result = Value der Hand	
			} else {
				game.getPlayers().get(game.getPl_on()).getSplithand().setResult(game.getPlayers().get(game.getPl_on()).getSplithand().getValue());
			}
			//Ruft die Methode auf, die das Ergebnis für den resultdialog setzt
			ctrl_dialogs.setWhatplayerhas();
		//Wird keine Splithand gespielt, wird alles auf die Mainhand bezogen	
		} else {
			int v = game.getPlayers().get(game.getPl_on()).getHand().getValue();
			if (v == 21 && game.getPlayers().get(game.getPl_on()).getHand().getCards().size() == 2) {
				game.getPlayers().get(game.getPl_on()).getHand().setResult(99);
			} else {
				game.getPlayers().get(game.getPl_on()).getHand().setResult(game.getPlayers().get(game.getPl_on()).getHand().getValue());
			}	
			ctrl_dialogs.setWhatplayerhas();
		}
		nextPlayer();
	}
	
	//Setzt das Ergebnis des Dealers
	public void setDealerResult() {
		int v = game.getDealer().getHand().getValue();
		//Hat der Dealer BlackJack? -> Result = 99
		if (v == 21 && game.getDealer().getHand().getCards().size() == 2) {
			game.getDealer().getHand().setResult(99);
		//Kein BlackJack? -> Result = Value der Hand	
		} else {
			game.getDealer().getHand().setResult(game.getDealer().getHand().getValue());
		}
		//Ruft die Methode auf, die das Ergebnis für den resultdialog setzt
		ctrl_dialogs.setWhatdealerhas();
	}
	
	//Aktiviert einen Button
	public void actButton(int nr) {
		mainview.getJbuttons().get(nr).setEnabled(true);
	}
	
	//Deaktiviert einen Button
	public void deactButton(int nr) {
		mainview.getJbuttons().get(nr).setEnabled(false);
	}
	
	//Startet das Austeilen der Karten
	public void dealCards() {
		counter_dealcards = 0;
		game.setPl_on(0);
		timer_dealcards.start();
	}
	
	//Austeilen einer Karte in der Deal-Phase
	public void dealAcard() {
		//Falls der aktuelle Spieler outofstack ist, wird pl_on erhöht und die Methode erneut aufgerufen
		if (game.getPlayers().get(game.getPl_on()).isIsoutofstack() == true) {
			game.setPl_on((game.getPl_on() + 1));
			dealAcard();
		//Hat der Spieler noch Stack bekommt er eine Karte	
		} else {
			game.getPlayers().get(game.getPl_on()).getHand().getCards().add(deck.getDeck().get(game.getCardcount()));
			game.getPlayers().get(game.getPl_on()).getHand().setValue(game.getPlayers().get(game.getPl_on()).getHand().getValue() + deck.getDeck().get(game.getCardcount()).getValue());
			//Animation des Austeilens
			ctrl_mainview.moveCard();
			//Setzt den Wert der Hand in der View
			ctrl_mainview.setValue();
		}	
	}
	
	//Austeilen einer Karte ausserhalb der Deal-Phase
	public void addCard() {
		//falls der aktuelle Spieler outofstack ist, wird pl_on erhöht und die Methode erneut aufgerufen
		if (game.getPlayers().get(game.getPl_on()).isIsoutofstack() == true) {
			game.setPl_on((game.getPl_on() + 1));
			addCard();
		//Hat der Spieler noch Stack bekommt er eine Karte		
		} else {
			//Prüft, ob eine Splithand gespielt wird ...
			if (game.getPlayers().get(game.getPl_on()).isSplitActive() == true) {
				game.getPlayers().get(game.getPl_on()).getSplithand().getCards().add(deck.getDeck().get(game.getCardcount()));
				game.getPlayers().get(game.getPl_on()).getSplithand().setValue(game.getPlayers().get(game.getPl_on()).getSplithand().getValue() + deck.getDeck().get(game.getCardcount()).getValue());
				//Animation des Austeilens
				ctrl_mainview.moveSplitCard();
				//Setzt den Wert der Hand in der View
				ctrl_mainview.setSplitValue();
			//... andernfalls bekommt die Mainhand eine Karte	
			} else {
				game.getPlayers().get(game.getPl_on()).getHand().getCards().add(deck.getDeck().get(game.getCardcount()));
				game.getPlayers().get(game.getPl_on()).getHand().setValue(game.getPlayers().get(game.getPl_on()).getHand().getValue() + deck.getDeck().get(game.getCardcount()).getValue());
				//Animation des Austeilens
				ctrl_mainview.moveCard();
				//Setzt den Wert der Hand in der View
				ctrl_mainview.setValue();
			}
		//Aktiviert die Buttons anhand von Stack, Bet und Hand
		setButtons();	
		}	
	}
	
	//Austeilen einer Karte für den Dealer
	public void addDealerCard () {
		game.getDealer().getHand().getCards().add(deck.getDeck().get(game.getCardcount()));
		game.getDealer().getHand().setValue(game.getDealer().getHand().getValue() + deck.getDeck().get(game.getCardcount()).getValue());
		//Animation des Austeilens
		ctrl_mainview.moveDealerCard();
		//Setzt den Wert der Hand in der View
		ctrl_mainview.setDealerValue();
	}
	
	//Startet die erste Runde
	public void startPlay() {
		//Prüft, ob die Spieler noch Stack haben. Hat ein Spieler noch Stack ist er dran und die For-Schleife wird beendet
		for (int i = 0; i < game.getPl_quant(); i++) {
			if (game.getPlayers().get(i).isIsoutofstack() == false) {
				game.setPl_on(i);
				break;
			}
		}
		//Setzt den Spieler in der View auf aktiv
		ctrl_mainview.setPlayer();
		//Ist ein Spieler nach dem Austeilen dran, dann sind die Buttons "New Card"(0) und "Stand"(3) auf jeden Fall aktiv
		deactButton(5);
		actButton(0);
		actButton(3);
		//Ermittelt Stack und Bet des Players um ggf. weitere Buttons zu aktivieren
		int s = game.getPlayers().get(game.getPl_on()).getStack();
		int b = game.getPlayers().get(game.getPl_on()).getBet();
		//Ist der Stack des Spielers mind. doppelt so groß wie Bet, dann darf gedoubled werden (-> Button "Double"(1) aktiv)
		if (game.getPlayers().get(game.getPl_on()).getStack() >= (b * 2)) {
			actButton(1);
		} else {
			deactButton(1);
		}
		//Sind die Kartenwerte der beiden Karten gleich und der Stack mind. doppelt so groß wie Bet, dann darf gesplittet werden (-> "Split"(4) aktiv) 
		if (game.getPlayers().get(game.getPl_on()).getHand().getCards().get(0).getValue() == game.getPlayers().get(game.getPl_on()).getHand().getCards().get(1).getValue() && s >= (b*2)) {
			actButton(4);
		} else {
			deactButton(4);
		}
		//Animation "Player X is up"
		ctrl_mainview.movePlayerShip();
	}
	
	//Prüft, ob Player outofstack sind
	public void checkStacks() {
		for (int i = 0; i < game.getPl_quant(); i++) {
			//Prüft, ob ein Player keinen Stack mehr hat und nicht schon vorher "outofstack" war
			if (game.getPlayers().get(i).getStack() <= 0 && game.getPlayers().get(i).isIsoutofstack() == false) {
				//Ist das der Fall, dann wird der outofstackdialog aufgerufen und die For-Schleife wird beendet
				outofstackdialog.getOutofstack1().setText(game.getPlayers().get(i).getName());
				outofstackdialog.getOutofstack1().setVisible(true);
				outofstackdialog.getOutofstack2().setVisible(true);
				outofstackdialog.getB_ok().setVisible(true);
				game.getPlayers().get(i).setIsoutofstack(true);
				game.setPl_outofstack((game.getPl_outofstack()+1));
				ctrl_dialogs.showDialog(outofstackdialog);
				break;
			//Erfüllt kein Spieler mehr die If-Bedinungung, dann startet die Runde	
			} else {
				if (i == (game.getPl_quant()-1)) {
					startRound();
				}
			}	
		}
	}
	
	//Startet eine neue Runde
	public void startRound() {
		//Sind alle Spieler "outofstack", dann endet das Spiel ...
		if (game.getPl_outofstack() == game.getPl_quant()) {
			ctrl_mainview.byeBye();
		//... andernfalls gehts los -> der Button "Bet"(2) wird aktiviert	
		} else {
			game.setCardcount(0);
			game.setPl_on(0);
			deactButton(0);
			deactButton(1);
			deactButton(3);
			deactButton(4);
			deactButton(5);
			actButton(2);
		}	
	}
	
	//Aktiviert den nächsten Spieler
	public void nextPlayer() {
		//deaktiviert das Double-Flag des vorherigen Spielers
		game.getPlayers().get(game.getPl_on()).setDoubleActive(false);
		//prüft, ob eine Splithand vorhanden ist und setzt dann entsprechend das Split-Flag und teilt der Splithand eine 2. Karte aus
		if (game.getPlayers().get(game.getPl_on()).getSplithand().getCards().size() == 1) {
			game.getPlayers().get(game.getPl_on()).setSplitActive(true);
			ctrl_mainview.setSplitPlayer();
			addCard();
		} else {
			game.getPlayers().get(game.getPl_on()).setSplitActive(false);
			//falls es noch weitere Spieler gibt, wir pl_on erhöht ...
			if (game.getPl_on() < (game.getPl_quant() - 1)) {
				game.setPl_on((game.getPl_on() + 1));
				//prüft, ob der nächste Spieler noch Stack hat ...
				if (game.getPlayers().get(game.getPl_on()).isIsoutofstack() == false) {
					//Aktiviert die Buttons anhand von Stack, Bet und Hand
					setButtons();
					//Setzt der Spieler in der View auf aktiv
					ctrl_mainview.setPlayer();
					//Animation "Player X is up"
					ctrl_mainview.movePlayerShip();
				//... falls nicht, wird übersprungen	
				} else {
					nextPlayer();
				}
			} 
			//... andernfalls ist der Dealer dran
			else  {
				//Die Anmation "Dealer is up" wird nur abgespielt, wenn nicht alle aktiven Spieler Bust haben
				if (game.getPlayer_busts() >= (game.getPl_quant() - game.getPl_outofstack())) {
					dealersMove();
				} else {
					ctrl_mainview.moveDealerShip();
				}	
			}
		}	
	}
	
	//Aktiviert die Buttons anhand von Stack, Bet und Hand
	public void setButtons() {
		int s = game.getPlayers().get(game.getPl_on()).getStack();
		int b = game.getPlayers().get(game.getPl_on()).getBet();
		int sb = game.getPlayers().get(game.getPl_on()).getSplitbet();
		//Prüft, ob eine Splithand gespielt wird - die wäre dann für die Aktivierung der Buttons entscheidend
		if (game.getPlayers().get(game.getPl_on()).isSplitActive() == true) {
			//eine Splithand kann nicht noch einmal gesplittet werden (-> Button 4 deaktiv)
			deactButton(4);
			deactButton(5);
			actButton(0);
			actButton(3);
			//Falls die Hand genau 2 Karten hat und falls der Stack größer/gleich (bet+ 2*splitbet) ist, dann darf gedoppelt werden
			if (game.getPlayers().get(game.getPl_on()).getSplithand().getCards().size() == 2 && s >= (b + (sb*2))) {
				actButton(1);
			} else {
				deactButton(1);
			}
		//Keine Splithand? -> Mainhand ist ausschlaggebend	
		} else {
			deactButton(5);
			actButton(0);
			actButton(3);
			//Falls der Stack größer/gleich (bet*2) ist, dann darf gedoppelt werden
			if (game.getPlayers().get(game.getPl_on()).getHand().getCards().size() == 2 && s >= (b*2)) {
				actButton(1);
			} else {
				deactButton(1);
			}
			//Prüft, ob bereits gesplittet wurde (-> Splithand-Size > 0), falls nicht, darf ggf. gesplittet werden
			if (game.getPlayers().get(game.getPl_on()).getSplithand().getCards().size() == 0) {
				//Falls die Werte der ersten und der zweiten Karte gleich sind, und falls der Stack größer/gleich (bet*2) ist dann darf gesplittet werden.
				if (game.getPlayers().get(game.getPl_on()).getHand().getCards().get(0).getValue() == game.getPlayers().get(game.getPl_on()).getHand().getCards().get(1).getValue() && s >= (b*2)) {
					actButton(4);
				} else {
					deactButton(4);
				}
			} else {
				deactButton(4);
			}
		}
	}
	
	//Methode für Double
	public void doubleDown() {
		//Setzt das Double-Flag
		game.getPlayers().get(game.getPl_on()).setDoubleActive(true);
		//Prüft, ob eine Splithand gespielt wird
		if (game.getPlayers().get(game.getPl_on()).isSplitActive() == true) {
			//Verdoppelt den Einsatz
			game.getPlayers().get(game.getPl_on()).setSplitbet((game.getPlayers().get(game.getPl_on()).getSplitbet() * 2));
			//Anzeigen des neuen Einsatzes in der View
			ctrl_mainview.setSplitBet();
//			counter_doubledown = 0;
//			timer_doubledown.start();
		//Keine Splithand? -> Mainhand	
		} else {
			//Verdoppelt den Einsatz
			game.getPlayers().get(game.getPl_on()).setBet((game.getPlayers().get(game.getPl_on()).getBet() * 2));
			//prüft, ob es eine Splithand gibt (die als nächstes gespielt wird), damit die bets ggf. korrekt angezeigt werden
			if (game.getPlayers().get(game.getPl_on()).getSplithand().getCards().size() > 0) {
				//Anzeigen des neuen Einsatzes in der View
				ctrl_mainview.setSplitBet();
			} else {
				//Anzeigen des neuen Einsatzes in der View
				ctrl_mainview.setBet();
			}			
//			counter_doubledown = 0;
//			timer_doubledown.start();
		}
		//Nach dem Doublen wird (genau) eine Karte ausgegeben
		addCard();
	}
	
	//Methode für Split
	public void splitHand() {
		//Fügt der Splihand die zweite Karte der Mainhand zu
		game.getPlayers().get(game.getPl_on()).getSplithand().getCards().add(game.getPlayers().get(game.getPl_on()).getHand().getCards().get(1));
		//Entfernt die Karte aus der Mainhand
		game.getPlayers().get(game.getPl_on()).getHand().getCards().remove(1);
		//Setzten des neuen Wertes der Mainhand
		game.getPlayers().get(game.getPl_on()).getHand().setValue(game.getPlayers().get(game.getPl_on()).getHand().getCards().get(0).getValue());
		//Setzten des neuen Wertes der Splithand
		game.getPlayers().get(game.getPl_on()).getSplithand().setValue(game.getPlayers().get(game.getPl_on()).getSplithand().getCards().get(0).getValue());
		//Setzen des neuen Einsatzes
		game.getPlayers().get(game.getPl_on()).setSplitbet(game.getPlayers().get(game.getPl_on()).getBet());
		//Anzeige des neuen Einsatzes und der Splikarte in der View
		ctrl_mainview.setSplitBet();
		ctrl_mainview.setSplitCard();
		//Die Mainhand bekommt eine neue 2. Karte
		addCard();
		//Aktiviert die Buttons anhand von Stack, Bet und Hand
		setButtons();
	}	
	
	//Methode, um zu prüfen, ob eine Hand Bust ist (inkl. Ass-Korrektur)
	public void checkBust() {
		//Prüft, ob eine Splithand gespielt wird
		if (game.getPlayers().get(game.getPl_on()).isSplitActive() == true) {
			//Per "ace_corrector" werden Asse im Falle von Bust nur als 1 gewertet...
			ace_corrector = 0;
			int v = 0;
			//Ermittelt den Wert einer Hand
			for (int i = 0; i < game.getPlayers().get(game.getPl_on()).getSplithand().getCards().size(); i++) {
				v = v + game.getPlayers().get(game.getPl_on()).getSplithand().getCards().get(i).getValue();
			}
			//... aber nur, wenn die Punktzahl > 21 ist
			if (v > 21){
				//Ist die Punktzahl < 32, dann muss nur ein Ass als 1 gewertet werden (= Punkte - 10)
				if (v < 32) {
					for (int i = 0; i < game.getPlayers().get(game.getPl_on()).getSplithand().getCards().size(); i++){
						if (game.getPlayers().get(game.getPl_on()).getSplithand().getCards().get(i).getValue() == 11){
							ace_corrector = 10;
						}
					}
				}
				//Liegt die Punktzahl über 32, dann müssen 2 Asse als 1 gewertet werden (= Punkte - 20)
				else {
					for (int i = 0; i < game.getPlayers().get(game.getPl_on()).getSplithand().getCards().size(); i++){
						if (game.getPlayers().get(game.getPl_on()).getSplithand().getCards().get(i).getValue() == 11){
							ace_corrector = ace_corrector + 10;
						}
					}
				}
				//Setzt den Wert der Hand unter Berücksichtigung der Ass-Korrektur
				game.getPlayers().get(game.getPl_on()).getSplithand().setValue(v - ace_corrector);
				//Anzeige des neuen Wertes in der View
				ctrl_mainview.setSplitValue();
				//Reset des Ass-Korrektors
				ace_corrector = 0;
			}
			//Prüft, ob die Hand trotz Ass-Korrektur noch immer Bust ist
			v = game.getPlayers().get(game.getPl_on()).getSplithand().getValue();
			if (v > 21 && v < 99) {
				//Erhöht den Zähler für Bust-Hände
				game.setPlayer_busts((game.getPlayer_busts() + 1));
				//Anzeigen von Bust in der View
				ctrl_mainview.setBust();
				
				//TODO setResult wird über setBust aufgreufen kann daher hier vermutlich raus
				//setResult();
				
				//TODO wird über setResult aufgrufen und kann daher vermutlich raus
				//falls gedoubled wurde wird nextPlayer am Ende der Methode aufgerufen. Die If-Bedingungen verhindert den doppelten Aufruf
//				if (game.getPlayers().get(game.getPl_on()).isDoubleActive() == false) {
//					nextPlayer();
//				}
				
			//Falls kein Bust vorliegt, wird geprüft, ob gedoubled wurde. Falls ja -> nächster Spieler (über setResult)	
			} else {
				if (game.getPlayers().get(game.getPl_on()).isDoubleActive() == true) {
					setResult();
				} 
			}
		//Keine Splithand? -> Die Prozedur wird auf die Mainhand angewendet	
		} else {
			//Per "ace_corrector" werden Asse im Falle von bust nur als 1 gewertet...
			ace_corrector = 0;
			int v = 0;
			for (int i = 0; i < game.getPlayers().get(game.getPl_on()).getHand().getCards().size(); i++) {
				v = v + game.getPlayers().get(game.getPl_on()).getHand().getCards().get(i).getValue();
			}
			//... aber nur, wenn die Punktzahl > 21 ist
			if (v > 21){
				//Ist die Punktzahl < 32, dann muss nur ein Ass als 1 gewertet werden (= Punkte - 10)
				if (v < 32) {
					for (int i = 0; i < game.getPlayers().get(game.getPl_on()).getHand().getCards().size(); i++){
						if (game.getPlayers().get(game.getPl_on()).getHand().getCards().get(i).getValue() == 11){
							ace_corrector = 10;
						}
					}
				}
				//Liegt die Punktzahl über 32, dann müssen 2 Asse als 1 gewertet werden (= Punkte - 20)
				else {
					for (int i = 0; i < game.getPlayers().get(game.getPl_on()).getHand().getCards().size(); i++){
						if (game.getPlayers().get(game.getPl_on()).getHand().getCards().get(i).getValue() == 11){
							ace_corrector = ace_corrector + 10;
						}
					}
				}
				//Setzt den Wert der Hand unter Berücksichtigung der Ass-Korrektur
				game.getPlayers().get(game.getPl_on()).getHand().setValue(v - ace_corrector);
				//Anzeige des neuen Wertes in der View
				ctrl_mainview.setValue();
				//Reset des Ass-Korrektors
				ace_corrector = 0;
			}
			//Prüft, ob die Hand trotz Ass-Korrektur noch immer Bust ist
			v = game.getPlayers().get(game.getPl_on()).getHand().getValue();
			if (v > 21 && v < 99) {
				//Erhöht den Zähler für Bust-Hände
				game.setPlayer_busts((game.getPlayer_busts() + 1));
				//Anzeigen von Bust in der View
				ctrl_mainview.setBust();
				
				//TODO setResult wird über setBust aufgreufen kann daher hier vermutlich raus
				//setResult();
				
				//TODO wird über setResult aufgrufen und kann daher vermutlich raus
				//falls gedoubled wurde wird nextPlayer am Ende der Methode aufgerufen. Die If-Bedingungen verhindert den doppelten Aufruf
//				if (game.getPlayers().get(game.getPl_on()).isDoubleActive() == false) {
//					nextPlayer();
//				}
				
			//Falls kein Bust vorliegt, wird geprüft, ob gedoubled wurde. Falls ja -> nächster Spieler (über setResult)	
			} else {
				if (game.getPlayers().get(game.getPl_on()).isDoubleActive() == true) {
					setResult();
				} 
			} 
		}
		// TO DO das wird über die else-Bedingung oben aufgreufen und kann vermutlich ganz raus
		//falls gedoubled wurde, ist auf jeden Fall der nächste Spieler dran
//		if (game.getPlayers().get(game.getPl_on()).isDoubleActive() == true) {
//			setResult();
//			
//			//TO DO wird über setResult aufgrufen und kann daher vermutlich raus
//			//nextPlayer();
//		}
	}
	
	public void checkDealerBust() {
		//Per "ace_corrector" werden Asse im Falle von bust nur als 1 gewertet...
		ace_corrector = 0;
		int v = 0;
		for (int i = 0; i < game.getDealer().getHand().getCards().size(); i++) {
			v = v + game.getDealer().getHand().getCards().get(i).getValue();
		}
		//... aber nur, wenn die Punktzahl > 21 ist
		if (v > 21){
			//Ist die Punktzahl < 32, dann muss nur ein Ass als 1 gewertet werden (= Punkte - 10)
			if (v < 32) {
				for (int i = 0; i < game.getDealer().getHand().getCards().size(); i++){
					if (game.getDealer().getHand().getCards().get(i).getValue() == 11){
						ace_corrector = 10;
					}
				}
			}
			//Liegt die Punktzahl über 32, dann müssen 2 Asse als 1 gewertet werden (= Punkte - 20)
			else {
				for (int i = 0; i < game.getDealer().getHand().getCards().size(); i++){
					if (game.getDealer().getHand().getCards().get(i).getValue() == 11){
						ace_corrector = ace_corrector + 10;
					}
				}
			}
			//Setzt den Wert der Hand unter Berücksichtigung der Ass-Korrektur
			game.getDealer().getHand().setValue(v - ace_corrector);
			//Anzeige des neuen Wertes in der View
			ctrl_mainview.setDealerValue();
			//Reset des Ass-Korrektors
			ace_corrector = 0;
		}
		//Prüft, ob die Hand trotz Ass-Korrektur noch immer Bust ist
		v = game.getDealer().getHand().getValue();
		if (v > 21) {
			//Anzeige von Bust in der View
			ctrl_mainview.setDealerBust();
			
			//TO DO Wird bereits über den Timer aufgerufen, oder?
			//setDealerResult();
			//showResults();
		}
	}
	
	public void dealersMove() {
		ctrl_mainview.resetPlayers();
		//falls alle Spieler BUST haben: Dealer bekommt keine Karte mehr -> Results (Spieler ohne Stack werden abgezogen)
		if (game.getPlayer_busts() >= (game.getPl_quant() - game.getPl_outofstack())) {
			setDealerResult();
			showResults();
		}
		//... falls nein: (über Timer) Dealer zieht, solange er weniger als 17 hat. Bei 17 oder mehr darf er nicht mehr ziehen
		else {
			timer_dealersmove.setInitialDelay(100);
			timer_dealersmove.start();
		}
	}
	
	public void showResults() {
		for (int i = 0; i < game.getPl_quant(); i++) {
			int result_p = game.getPlayers().get(i).getHand().getResult();
			int result_ps = game.getPlayers().get(i).getSplithand().getResult();
			int result_d = game.getDealer().getHand().getResult();
			//Prüft, ob ein Ergebnis vorliegt (0 = Spieler ist out of stack)
			if (result_p > 0) {
				//Spieler hat BUST -> VERLOREN
				if (result_p > 21 && result_p < 99) {
					//Bet wird von Stack abgezogen
					game.getPlayers().get(i).setStack(game.getPlayers().get(i).getStack() - game.getPlayers().get(i).getBet());
				//Spieler hat Black Jack, Dealer hat KEIN Black Jack -> GEWONNEN (3:2)
				} else if (result_p == 99 && result_d != 99) {
					//3*Bet/2 wird dem Stack zugefügt
					game.getPlayers().get(i).setStack(game.getPlayers().get(i).getStack() + ((game.getPlayers().get(i).getBet()/2)*3));
					//YouWin-label wird angezeigt
					mainview.getContent().moveToFront(mainview.getPlayers().get(i).getYouwin());
					mainview.getPlayers().get(i).getYouwin().setVisible(true);
				//Spieler hat 21 oder weniger	
				} else {
					//Spieler hat mehr als der Dealer -> GEWONNEN
					if (result_p > result_d) {
						//Bet wird dem Stack zugefügt
						game.getPlayers().get(i).setStack(game.getPlayers().get(i).getStack() + game.getPlayers().get(i).getBet());
						//YouWin-label wird angezeigt
						mainview.getContent().moveToFront(mainview.getPlayers().get(i).getYouwin());
						mainview.getPlayers().get(i).getYouwin().setVisible(true);
					//Spieler hat genauso viel wie der Dealer -> UNENTSCHIEDEN, nichts passiert
					} else if (result_p == result_d) {
						//Draw-Label wird angezeigt
						mainview.getContent().moveToFront(mainview.getPlayers().get(i).getDraw());
						mainview.getPlayers().get(i).getDraw().setVisible(true);
					//Spieler hat weniger als der Dealer	
					} else {
						//Dealer hat BUST -> GEWONNEN
						if (result_d > 21 && result_d < 99) {
							//Bet wird dem Stack zugefügt
							game.getPlayers().get(i).setStack(game.getPlayers().get(i).getStack() + game.getPlayers().get(i).getBet());
						//Dealer hat Black Jack oder weniger als 22	-> VERLOREN
						} else {
							//bet wird vom Stack abgezogen
							game.getPlayers().get(i).setStack(game.getPlayers().get(i).getStack() - game.getPlayers().get(i).getBet());
							//DealerWins-Label wird angezeigt
							mainview.getContent().moveToFront(mainview.getPlayers().get(i).getDealerwins());
							mainview.getPlayers().get(i).getDealerwins().setVisible(true);
						}
					} 
				}
				//falls es auch eine Splithand gibt: Prozedur wie oben
				if (result_ps > 0) {
					//Spieler hat BUST -> VERLOREN
					if (result_ps > 21 && result_ps < 99) {
						game.getPlayers().get(i).setStack(game.getPlayers().get(i).getStack() - game.getPlayers().get(i).getSplitbet());
					//Spieler hat Black Jack, Dealer hat KEIN Black Jack -> GEWONNEN (3:2)
					} else if (result_ps == 99 && result_d != 99) {
						game.getPlayers().get(i).setStack(game.getPlayers().get(i).getStack() + ((game.getPlayers().get(i).getSplitbet()/2)*3));
						mainview.getContent().moveToFront(mainview.getPlayers().get(i).getSplit_youwin());
						mainview.getPlayers().get(i).getSplit_youwin().setVisible(true);
					//Spieler hat 21 oder weniger	
					} else {
						//Spieler hat mehr als der Dealer -> GEWONNEN
						if (result_ps > result_d) {
							game.getPlayers().get(i).setStack(game.getPlayers().get(i).getStack() + game.getPlayers().get(i).getSplitbet());
							mainview.getContent().moveToFront(mainview.getPlayers().get(i).getSplit_youwin());
							mainview.getPlayers().get(i).getSplit_youwin().setVisible(true);
						//Spieler hat genauso viel wie der Dealer -> UNENTSCHIEDEN, nichts passiert	
						} else if (result_ps == result_d) {
							mainview.getContent().moveToFront(mainview.getPlayers().get(i).getSplit_draw());
							mainview.getPlayers().get(i).getSplit_draw().setVisible(true);
						//Spieler hat weniger als der Dealer	
						} else {
							//Dealer hat BUST -> GEWONNEN
							if (result_d > 21 && result_d < 99) {
								game.getPlayers().get(i).setStack(game.getPlayers().get(i).getStack() + game.getPlayers().get(i).getSplitbet());
							//Dealer hat Black Jack oder weniger als 22	-> VERLOREN	
							} else {
								game.getPlayers().get(i).setStack(game.getPlayers().get(i).getStack() - game.getPlayers().get(i).getSplitbet());
								mainview.getContent().moveToFront(mainview.getPlayers().get(i).getSplit_dealerwins());
								mainview.getPlayers().get(i).getSplit_dealerwins().setVisible(true);
							}
						} 
					}
				}
			}	
		}
		//Reset von pl_on
		game.setPl_on(0);
		//Ruft den Results-Dialog auf
		ctrl_dialogs.showResults();
	}
	
	//Resetet die Hände und Werte aller Spieler (ausser Stack)
	public void resetPlayers() {
		for (int i = 0; i < game.getPl_quant(); i++) {
			game.getPlayers().get(i).getHand().getCards().clear();
			game.getPlayers().get(i).getSplithand().getCards().clear();
			game.getPlayers().get(i).getHand().setResult(0);
			game.getPlayers().get(i).getHand().setValue(0);
			game.getPlayers().get(i).getHand().setBet(0);
			game.getPlayers().get(i).setBet(0);
			game.getPlayers().get(i).setSplitbet(0);
			game.getPlayers().get(i).getSplithand().setResult(0);
			game.getPlayers().get(i).getSplithand().setValue(0);
			game.getPlayers().get(i).getSplithand().setBet(0);
			game.getPlayers().get(i).setSplitActive(false);
			game.setPlayer_busts(0);
		}
	}
	
	//Resetet die Hand und die Werte des Dealers
	public void resetDealer() {
		game.getDealer().getHand().getCards().clear();
		game.getDealer().getHand().setResult(0);
		game.getDealer().getHand().setValue(0);
	}	

	//Aktiviert Listener für alle Buttons
	public void addListener() {
		//Buttons der MainView
		this.mainview.setMainListener(new ActionListener() {
			
			public void actionPerformed(ActionEvent ae) {
				//Button "New Card"
				if (ae.getSource() == mainview.getButton_newcard()) {
					//Spieler zieht eine Karte
					addCard();
				//Button "Stand"	
				} else if (ae.getSource() == mainview.getButton_stand()) {
					//Ergebnis der aktiven Hand wird gesetzt
					setResult();
				//Button "Double"	
				} else if (ae.getSource() == mainview.getButton_double()) {
					//Ruft den Info-Dialog auf
					infodialog.getDouble1().setVisible(true);
					infodialog.getDouble2().setVisible(true);
					infodialog.getDouble3().setVisible(true);
					infodialog.getB_yes().setVisible(true);
					infodialog.getB_no().setVisible(true);
					ctrl_dialogs.showDialog(infodialog);
				//Button "Split"	
				} else if (ae.getSource() == mainview.getButton_split()) {
					//Hand wird gesplittet
					splitHand();
				//Button "Bet"	
				} else if (ae.getSource() == mainview.getButton_bet()) {
					//Prüft, ob der aktuelle Spieler outofstack ist. Falls ja, wird pl_on erhöht. Hat ein Spieler noch Stack, dann wird der Bet-Dialog aufgerufen
					for (int i = 0; i < game.getPl_quant(); i++) {
						if (game.getPlayers().get(i).isIsoutofstack() == true) {
							game.setPl_on((game.getPl_on() + 1));
						} else {
							break;
						}
					}
					//Modifiziert die JLabels im Bet-Dialog und ruft dann das Fenster auf
					betdialog.getBet_minmax().setText("(Minimum 1 / Maximum " + game.getPlayers().get(game.getPl_on()).getStack() + ")");
					betdialog.getBet_name().setText(game.getPlayers().get(game.getPl_on()).getName());
					ctrl_dialogs.showDialog(betdialog);
				//Button "Deal"	
				} else if (ae.getSource() == mainview.getButton_deal()) {
					//Deaktiviert den Deal-Button (Kann nur 1x am Anfang der Runde gedrückt werden)
					deactButton(5);
					//Mischt das Deck
					Collections.shuffle(deck.getDeck());
					//Resetet cardcount
					game.setCardcount(0);
					//Teilt Karten aus
					dealCards();
				//Button "Help"	
				} else if (ae.getSource() == mainview.getButton_help()) {
					//Ruft den Dialog mit den Regeln auf
					ctrl_dialogs.showDialog(rulesdialog);
				}
			}
		});
		//Buttons des StartDialogs
		this.startdialog.setStartListener(new ActionListener() {
			
			public void actionPerformed(ActionEvent ae) {
				//Buttons 1-4 legen die Anzahl der Mitspieler fest. Anschließend wird der StartDialog geschlossen und der NamesDialog geöffnet
				if (ae.getSource() == startdialog.getButton1()) {
					game.setPl_quant(1);
					addPlayers(1);
					ctrl_dialogs.closeDialog(startdialog);
					ctrl_dialogs.showDialog(namesdialog);
				} else if (ae.getSource() == startdialog.getButton2()) {
					game.setPl_quant(2);
					addPlayers(2);
					ctrl_dialogs.closeDialog(startdialog);
					ctrl_dialogs.showDialog(namesdialog);					
				} else if (ae.getSource() == startdialog.getButton3()) {
					game.setPl_quant(3);
					addPlayers(3);
					ctrl_dialogs.closeDialog(startdialog);
					ctrl_dialogs.showDialog(namesdialog);
				} else if (ae.getSource() == startdialog.getButton4()) {
					game.setPl_quant(4);
					addPlayers(4);
					ctrl_dialogs.closeDialog(startdialog);
					ctrl_dialogs.showDialog(namesdialog);
				}
			}
		});
		//Buttons des NamesDialogs
		this.namesdialog.setNamesListener(new ActionListener() {
			
			public void actionPerformed(ActionEvent ae) {
				//Button "OK"
				if (ae.getSource() == namesdialog.getB_names_ok()) {
					//Prüft, ob noch Spieler folgen
					if (game.getPl_quant() > (namesdialog.getCount() + 1)) {
						//falls ja ...
						int i = namesdialog.getCount();
						//... wird das Feld name_input ausgelesen und dem aktiven Spieler als Name zugeordnet 
						try {
							game.getPlayers().get(i).setName(namesdialog.getName_input().getText());
						}
						catch (NumberFormatException e) {
							// TODO Auto-generated catch block
						}
						//Anzeige des Namens in der View
						ctrl_mainview.setName(i);
						//Erhöht die Player-Anzeige (Player 1, Player 2 etc.) im Dialog
						namesdialog.getNames_player().setText("Player " + String.valueOf(i+2));
						//Resetet das Feld name_input
						namesdialog.getName_input().setText("");
						//Erhöht den Counter -> nächster Spieler
						namesdialog.setCount(i+1);
					} else {
						//falls nein ...
						int i = namesdialog.getCount();
						//... wird das Feld name_input ausgelesen und dem aktiven Spieler als Name zugeordnet 
						try {
							game.getPlayers().get(i).setName(namesdialog.getName_input().getText());
						}
						catch (NumberFormatException e) {
							// TODO Auto-generated catch block
						}
						//Anzeige des Namens in der View
						ctrl_mainview.setName(i);
						//Schließt den NamesDailog
						namesdialog.setVisible(false);
						namesdialog.dispose();
						//Öffnet den StartstackDialog
						ctrl_dialogs.showDialog(startstackdialog);
					}
				// TODO gibt es den Button "Start Game" hier überhaupt	
				} else if (ae.getSource() == namesdialog.getB_names_startgame()) {
					
				}
			}
		});
		//Buttons des StartstackDialogs
		this.startstackdialog.setStartstackListener(new ActionListener() {
						
			public void actionPerformed(ActionEvent ae) {
				//Button "OK"
				if (ae.getSource() == startstackdialog.getStartstack_ok()) {
					//Startet die Ermittlung des Startstacks
					ctrl_dialogs.getTheStartstack1();
				//Button "Start"	
				} else if (ae.getSource() == startstackdialog.getStartstack_start()) {
					//Resetet die Spieler
					resetPlayers();
					//Resetet outofstack
					game.setPl_outofstack(0);
					//Startet die "BenderWalks-Animation"
					ctrl_dialogs.benderWalks();					
				}
			}
		});
		//Buttons des BetDialogs
		this.betdialog.setBetListener(new ActionListener() {
					
			public void actionPerformed(ActionEvent ae) {
				//Buttons +1, +10, +100 erhöhen die Bet um 1, 10 oder 100 (über raiseBet)
				if (ae.getSource() == betdialog.getB_bet_plus1()) {
					ctrl_dialogs.raiseBet(1);
				} else if (ae.getSource() == betdialog.getB_bet_plus10()) {
					ctrl_dialogs.raiseBet(10);
				} else if (ae.getSource() == betdialog.getB_bet_plus100()) {
					ctrl_dialogs.raiseBet(100);
				//Button "Max" setzt die Bet auf den Wert des Stacks	
				} else if (ae.getSource() == betdialog.getB_bet_max()) {
					game.getPlayers().get(game.getPl_on()).setBet((game.getPlayers().get(game.getPl_on()).getStack()));
					//Anzeige des Wertes im Dialog
					betdialog.getThebet().setText(String.valueOf(game.getPlayers().get(game.getPl_on()).getBet()));
				//Buttons -1, -10, -100 verringern die Bet um 1, 10 oder 100 (über raiseBet)	
				} else if (ae.getSource() == betdialog.getB_bet_minus1()) {
					ctrl_dialogs.decrBet(1);
				} else if (ae.getSource() == betdialog.getB_bet_minus10()) {
					ctrl_dialogs.decrBet(10);
				} else if (ae.getSource() == betdialog.getB_bet_minus100()) {
					ctrl_dialogs.decrBet(100);
				//Button "Min" setzt die Bet auf 1
				} else if (ae.getSource() == betdialog.getB_bet_min()) {
					game.getPlayers().get(game.getPl_on()).setBet(1);
					//Anzeige des Wertes im Dialog
					betdialog.getThebet().setText(String.valueOf(game.getPlayers().get(game.getPl_on()).getBet()));
				//Button "OK"	
				} else if (ae.getSource() == betdialog.getB_bet_ok()) {
					//Prüft, ob der eingestellte Wert > 0 ist
					if (game.getPlayers().get(game.getPl_on()).getBet() > 0) {
						//prüft, ob noch Spieler folgen ...
						if (game.getPl_on() < (game.getPl_quant() - 1)) {
							//Setzt den Bet-Wert in der View
							ctrl_mainview.setBet();
							//erhöht pl_on -> nächster Spieler
							game.setPl_on(game.getPl_on() + 1);
							//prüft, ob die nachfolgenden Spieler outofstack sind ...
							for (int i = game.getPl_on(); i < game.getPl_quant(); i++) {
								//... ist das der Fall, wird pl_on weiter erhöht
								if (game.getPlayers().get(i).isIsoutofstack() == true) {
									game.setPl_on((game.getPl_on() + 1));
								//sobald ein Spieler "on" ist, der noch Stack hat gehts weiter	
								} else {
									break;
								}
							}
							//hier wird noch einmal geprüft, ob pl_on noch innerhalb der Player-Range ist, ansonsten gäbe es eine outofbounds-exception
							if (game.getPl_on() < game.getPl_quant()) {
								//Modifiziert die JLabels für den aktiven Spieler
								betdialog.getBet_minmax().setText("(Minimum 1 / Maximum " + game.getPlayers().get(game.getPl_on()).getStack() + ")");
								betdialog.getBet_name().setText(game.getPlayers().get(game.getPl_on()).getName());
								//Resetet die Bet-Anzeige im Dialog
								betdialog.getThebet().setText("0");
							//folgen keine Spieler mehr, gehts los	
							} else {
								//Resetet pl_on
								game.setPl_on(0);
								//Schließt den BetDialog
								ctrl_dialogs.closeDialog(betdialog);
								//Resetet die Bet-Anzeige im Dialog
								betdialog.getThebet().setText("0");
								//Deaktiviert den bet-Button
								deactButton(2);
								//Aktiviert den Deal-Button
								actButton(5);
							}
						// ... andernfalls gehts los	
						} else {
							//Anzeige des Bet-Wertes in der View
							ctrl_mainview.setBet();
							//Resetet pl_on
							game.setPl_on(0);
							//Schließt den BetDialog
							ctrl_dialogs.closeDialog(betdialog);
							//Resetet die Bet-Anzeige im Dialog
							betdialog.getThebet().setText("0");
							//Deaktiviert den bet-Button
							deactButton(2);
							//Aktiviert den Deal-Button
							actButton(5);
						}
					}	
				}
			}
		});
		//Buttons des RulesDialogs
		this.rulesdialog.setRulesListener(new ActionListener() {
			
			public void actionPerformed(ActionEvent ae) {
				//Button "Back"
				if (ae.getSource() == rulesdialog.getB_rules_back()) {
					//Schließt den RulesDialog
					ctrl_dialogs.closeDialog(rulesdialog);
				}
			}
		});
		//Buttons des InfoDialogs
		this.infodialog.setInfoListener(new ActionListener() {
			
			public void actionPerformed(ActionEvent ae) {
				//Button "Yes"
				if (ae.getSource() == infodialog.getB_yes()) {
					//Schließt den InfoDialog und deaktiviert die Elemente
					ctrl_dialogs.closeDialog(infodialog);
					infodialog.getDouble1().setVisible(false);
					infodialog.getDouble2().setVisible(false);
					infodialog.getDouble3().setVisible(false);
					infodialog.getB_yes().setVisible(false);
					infodialog.getB_no().setVisible(false);
					//Ruft die Methode zum Doublen auf
					doubleDown();
				//Button "No"	
				} else if (ae.getSource() == infodialog.getB_no()) {
					//Schließt den InfoDialog und deaktiviert die Elemente
					ctrl_dialogs.closeDialog(infodialog);
					infodialog.getDouble1().setVisible(false);
					infodialog.getDouble2().setVisible(false);
					infodialog.getDouble3().setVisible(false);
					infodialog.getB_yes().setVisible(false);
					infodialog.getB_no().setVisible(false);
				}
			}
		});
		//Buttons des ResultsDialogs 
		this.resultsdialog.setResultsListener(new ActionListener() {
			
			public void actionPerformed(ActionEvent ae) {
				//Button "Next Player"
				if (ae.getSource() == resultsdialog.getNextplayer()) {
					//Erhöht pl_on -> nächster Spieler
					game.setPl_on((game.getPl_on() + 1));
					//Setzt die Ergbenisse des nächsten Spielers im Dialog
					ctrl_dialogs.showResults();
				}
				//Button "Next Round"
				else if (ae.getSource() == resultsdialog.getNextround()) {
					//Schließt den ResultsDialog und deakiviert die Elemente
					ctrl_dialogs.closeDialog(resultsdialog);
					resultsdialog.getHl().setVisible(false);
					resultsdialog.getDealerhas().setVisible(false);
					resultsdialog.getPlayerhas().setVisible(false);
					resultsdialog.getResult_mainhand().setVisible(false);
					resultsdialog.getNextround().setVisible(false);
					resultsdialog.getQuitgame().setVisible(false);
					resultsdialog.getSplitPlayerhas().setVisible(false);
					resultsdialog.getResult_splithand().setVisible(false);
					for (int i = 0; i < game.getPl_quant(); i++) {
						//Prüft, ob Spieler outofstack sind
						if (game.getPlayers().get(i).getStack() <= 0) {
							//falls ja, wird das Outofstack-Label angezeigt
							mainview.getContent().moveToFront(mainview.getPlayers().get(i).getOutofstack());
							mainview.getPlayers().get(i).getOutofstack().setVisible(true);
						}
					}
					//Resetet den Tisch und die Spieler
					ctrl_mainview.resetTable();
					ctrl_mainview.resetPlayers();
					resetPlayers();
					resetDealer();
					//Methode, die ggf. den OutofstackDialog aufruft (falls ein Spieler outofstack ist)
					checkStacks();
				//TODO Wird der Button "New Game" überhaupt genutzt?	
				//Button "New Game"					
				} else if (ae.getSource() == resultsdialog.getNewgame()) {
					Main_Controller.getInstance().deactButton(0);
					Main_Controller.getInstance().deactButton(2);
					Main_Controller.getInstance().deactButton(1);
					Main_Controller.getInstance().deactButton(3);
					Main_Controller.getInstance().deactButton(4);
					Main_Controller.getInstance().deactButton(5);
					ctrl_dialogs.closeDialog(resultsdialog);
					resultsdialog.getHl().setVisible(false);
					resultsdialog.getDealerhas().setVisible(false);
					resultsdialog.getPlayerhas().setVisible(false);
					resultsdialog.getResult_mainhand().setVisible(false);
					resultsdialog.getNextround().setVisible(false);
					resultsdialog.getQuitgame().setVisible(false);
					ctrl_dialogs.showDialog(startdialog);
				//Button "Quit Game"	
				} else if (ae.getSource() == resultsdialog.getQuitgame()) {
					//Schließt den ResultsDialog
					ctrl_dialogs.closeDialog(resultsdialog);
					//Ruft die ByeBye Methode zum Beenden des Spiels auf
					ctrl_mainview.byeBye();
				}
			}
		});
		//Buttons des OutofstackDialogs
		this.outofstackdialog.setOutofstackListener(new ActionListener() {
			
			public void actionPerformed(ActionEvent ae) {
				//Button "OK"
				if (ae.getSource() == outofstackdialog.getB_ok()) {
					//Schließt den OutofstackDialog und deaktiviert die Elmente
					ctrl_dialogs.closeDialog(outofstackdialog);
					outofstackdialog.getOutofstack1().setVisible(false);
					outofstackdialog.getOutofstack2().setVisible(false);
					outofstackdialog.getB_ok().setVisible(false);
					//Methode, die ggf. den OutofstackDialog erneut aufruft (falls noch ein Spieler outofstack ist)
					checkStacks();
				} 
			}
		});
		//Buttons des ResolutionDialogs
		this.resolutiondialog.setResListener(new ActionListener() {
			
			public void actionPerformed(ActionEvent ae) {
				//Button "OK"
				if (ae.getSource() == resolutiondialog.getB_ok()) {
					int res_setter = 0;
					//Liest die ausgewählte Auflösung als String aus
					String res = resolutiondialog.getResDropdown().getSelectedItem().toString();
					//Vergleicht den ausgewählten String mit Elementen der Liste "Resolutions"
					for (int i = 0; i <= resolutiondialog.getResolutions().length; i++) {
						//Sobald die Strings übereinstimmen wird res_setter gesetzt und die Schleife unterbrochen
						if (res.equals(resolutiondialog.getResolutions()[i])) {
							res_setter = i;
							break;
						}
					}
					//Setzt die Auflösung des Spielfensters und aller Elemente anhand des res_setters
					switch (res_setter) {
					case 0: 	img.setResizefactor(0.5);
								break;
					case 1: 	img.setResizefactor(((double)600/900));
								break;
					case 2:		img.setResizefactor(((double)768/900));
								break;
					default:	img.setResizefactor(1);
								break;
					}
					//Ruft die Methode zum Sklaieren der Bilder auf
					img.scaleImgs();
					//Schließt den ResolutionDialog
					ctrl_dialogs.closeDialog(resolutiondialog);
					//Startet die MainView
					showView();
				} 
			}
		});
	}
	
	//Getter & Setter
	public int getCounter_dealcards() {
		return counter_dealcards;
	}

	public void setCounter_dealcards(int counter_dealcards) {
		this.counter_dealcards = counter_dealcards;
	}
	
	public int getCounter_doubledown() {
		return counter_doubledown;
	}

	public void setCounter_doubledown(int counter_doubledown) {
		this.counter_doubledown = counter_doubledown;
	}

	public Timer getTimer_dealcards() {
		return timer_dealcards;
	}

	public void setTimer_dealcards(Timer timer_dealcards) {
		this.timer_dealcards = timer_dealcards;
	}
	
	public Timer getTimer_dealersmove() {
		return timer_dealersmove;
	}

	public void setTimer_dealersmove(Timer timer_dealersmove) {
		this.timer_dealersmove = timer_dealersmove;
	}

	public Timer getTimer_doubledown() {
		return timer_doubledown;
	}

	public void setTimer_doubledown(Timer timer_doubledown) {
		this.timer_doubledown = timer_doubledown;
	}

	//Nur für Testläufe
	public void setTestValues(int t) {
		addPlayers(t+1);
		game.setPl_quant(t+1);
		for (int i = 0; i <= t; i++) {
			game.setPl_on(i);
			setStack(i, 150);
			ctrl_dialogs.raiseBet(50);
			game.getPlayers().get(i).setName("Player" + String.valueOf(i+1));
			ctrl_mainview.setName(i);
			ctrl_mainview.setBet();
		}
		deactButton(0);
		deactButton(1);
		deactButton(2);
		deactButton(3);
		actButton(4);
		actButton(5);
	}
}
